package com.fly.model;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TMeasureExample
{
    protected String orderByClause;
    
    protected List<Criteria> oredCriteria;
    
    public TMeasureExample()
    {
        oredCriteria = new ArrayList<Criteria>();
    }
    
    protected TMeasureExample(TMeasureExample example)
    {
        this.orderByClause = example.orderByClause;
        this.oredCriteria = example.oredCriteria;
    }
    
    public void setOrderByClause(String orderByClause)
    {
        this.orderByClause = orderByClause;
    }
    
    public String getOrderByClause()
    {
        return orderByClause;
    }
    
    public List<Criteria> getOredCriteria()
    {
        return oredCriteria;
    }
    
    public void or(Criteria criteria)
    {
        oredCriteria.add(criteria);
    }
    
    public Criteria createCriteria()
    {
        Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0)
        {
            oredCriteria.add(criteria);
        }
        return criteria;
    }
    
    protected Criteria createCriteriaInternal()
    {
        Criteria criteria = new Criteria();
        return criteria;
    }
    
    public void clear()
    {
        oredCriteria.clear();
    }
    
    public static class Criteria
    {
        protected List<String> criteriaWithoutValue;
        
        protected List<Map<String, Object>> criteriaWithSingleValue;
        
        protected List<Map<String, Object>> criteriaWithListValue;
        
        protected List<Map<String, Object>> criteriaWithBetweenValue;
        
        protected Criteria()
        {
            super();
            criteriaWithoutValue = new ArrayList<String>();
            criteriaWithSingleValue = new ArrayList<Map<String, Object>>();
            criteriaWithListValue = new ArrayList<Map<String, Object>>();
            criteriaWithBetweenValue = new ArrayList<Map<String, Object>>();
        }
        
        public boolean isValid()
        {
            return criteriaWithoutValue.size() > 0 || criteriaWithSingleValue.size() > 0 || criteriaWithListValue.size() > 0 || criteriaWithBetweenValue.size() > 0;
        }
        
        public List<String> getCriteriaWithoutValue()
        {
            return criteriaWithoutValue;
        }
        
        public List<Map<String, Object>> getCriteriaWithSingleValue()
        {
            return criteriaWithSingleValue;
        }
        
        public List<Map<String, Object>> getCriteriaWithListValue()
        {
            return criteriaWithListValue;
        }
        
        public List<Map<String, Object>> getCriteriaWithBetweenValue()
        {
            return criteriaWithBetweenValue;
        }
        
        protected void addCriterion(String condition)
        {
            if (condition == null)
            {
                throw new RuntimeException("Value for condition cannot be null");
            }
            criteriaWithoutValue.add(condition);
        }
        
        protected void addCriterion(String condition, Object value, String property)
        {
            if (value == null)
            {
                throw new RuntimeException("Value for " + property + " cannot be null");
            }
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("condition", condition);
            map.put("value", value);
            criteriaWithSingleValue.add(map);
        }
        
        protected void addCriterion(String condition, List<? extends Object> values, String property)
        {
            if (values == null || values.size() == 0)
            {
                throw new RuntimeException("Value list for " + property + " cannot be null or empty");
            }
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("condition", condition);
            map.put("values", values);
            criteriaWithListValue.add(map);
        }
        
        protected void addCriterion(String condition, Object value1, Object value2, String property)
        {
            if (value1 == null || value2 == null)
            {
                throw new RuntimeException("Between values for " + property + " cannot be null");
            }
            List<Object> list = new ArrayList<Object>();
            list.add(value1);
            list.add(value2);
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("condition", condition);
            map.put("values", list);
            criteriaWithBetweenValue.add(map);
        }
        
        public Criteria andIdIsNull()
        {
            addCriterion("id is null");
            return this;
        }
        
        public Criteria andIdIsNotNull()
        {
            addCriterion("id is not null");
            return this;
        }
        
        public Criteria andIdEqualTo(Long value)
        {
            addCriterion("id =", value, "id");
            return this;
        }
        
        public Criteria andIdNotEqualTo(Long value)
        {
            addCriterion("id <>", value, "id");
            return this;
        }
        
        public Criteria andIdGreaterThan(Long value)
        {
            addCriterion("id >", value, "id");
            return this;
        }
        
        public Criteria andIdGreaterThanOrEqualTo(Long value)
        {
            addCriterion("id >=", value, "id");
            return this;
        }
        
        public Criteria andIdLessThan(Long value)
        {
            addCriterion("id <", value, "id");
            return this;
        }
        
        public Criteria andIdLessThanOrEqualTo(Long value)
        {
            addCriterion("id <=", value, "id");
            return this;
        }
        
        public Criteria andIdIn(List<Long> values)
        {
            addCriterion("id in", values, "id");
            return this;
        }
        
        public Criteria andIdNotIn(List<Long> values)
        {
            addCriterion("id not in", values, "id");
            return this;
        }
        
        public Criteria andIdBetween(Long value1, Long value2)
        {
            addCriterion("id between", value1, value2, "id");
            return this;
        }
        
        public Criteria andIdNotBetween(Long value1, Long value2)
        {
            addCriterion("id not between", value1, value2, "id");
            return this;
        }
        
        public Criteria andNoIsNull()
        {
            addCriterion("no is null");
            return this;
        }
        
        public Criteria andNoIsNotNull()
        {
            addCriterion("no is not null");
            return this;
        }
        
        public Criteria andNoEqualTo(String value)
        {
            addCriterion("no =", value, "no");
            return this;
        }
        
        public Criteria andNoNotEqualTo(String value)
        {
            addCriterion("no <>", value, "no");
            return this;
        }
        
        public Criteria andNoGreaterThan(String value)
        {
            addCriterion("no >", value, "no");
            return this;
        }
        
        public Criteria andNoGreaterThanOrEqualTo(String value)
        {
            addCriterion("no >=", value, "no");
            return this;
        }
        
        public Criteria andNoLessThan(String value)
        {
            addCriterion("no <", value, "no");
            return this;
        }
        
        public Criteria andNoLessThanOrEqualTo(String value)
        {
            addCriterion("no <=", value, "no");
            return this;
        }
        
        public Criteria andNoLike(String value)
        {
            addCriterion("no like", value, "no");
            return this;
        }
        
        public Criteria andNoNotLike(String value)
        {
            addCriterion("no not like", value, "no");
            return this;
        }
        
        public Criteria andNoIn(List<String> values)
        {
            addCriterion("no in", values, "no");
            return this;
        }
        
        public Criteria andNoNotIn(List<String> values)
        {
            addCriterion("no not in", values, "no");
            return this;
        }
        
        public Criteria andNoBetween(String value1, String value2)
        {
            addCriterion("no between", value1, value2, "no");
            return this;
        }
        
        public Criteria andNoNotBetween(String value1, String value2)
        {
            addCriterion("no not between", value1, value2, "no");
            return this;
        }
        
        public Criteria andAsIsNull()
        {
            addCriterion("As_ is null");
            return this;
        }
        
        public Criteria andAsIsNotNull()
        {
            addCriterion("As_ is not null");
            return this;
        }
        
        public Criteria andAsEqualTo(Double value)
        {
            addCriterion("As_ =", value, "as");
            return this;
        }
        
        public Criteria andAsNotEqualTo(Double value)
        {
            addCriterion("As_ <>", value, "as");
            return this;
        }
        
        public Criteria andAsGreaterThan(Double value)
        {
            addCriterion("As_ >", value, "as");
            return this;
        }
        
        public Criteria andAsGreaterThanOrEqualTo(Double value)
        {
            addCriterion("As_ >=", value, "as");
            return this;
        }
        
        public Criteria andAsLessThan(Double value)
        {
            addCriterion("As_ <", value, "as");
            return this;
        }
        
        public Criteria andAsLessThanOrEqualTo(Double value)
        {
            addCriterion("As_ <=", value, "as");
            return this;
        }
        
        public Criteria andAsIn(List<Double> values)
        {
            addCriterion("As_ in", values, "as");
            return this;
        }
        
        public Criteria andAsNotIn(List<Double> values)
        {
            addCriterion("As_ not in", values, "as");
            return this;
        }
        
        public Criteria andAsBetween(Double value1, Double value2)
        {
            addCriterion("As_ between", value1, value2, "as");
            return this;
        }
        
        public Criteria andAsNotBetween(Double value1, Double value2)
        {
            addCriterion("As_ not between", value1, value2, "as");
            return this;
        }
        
        public Criteria andCrIsNull()
        {
            addCriterion("Cr is null");
            return this;
        }
        
        public Criteria andCrIsNotNull()
        {
            addCriterion("Cr is not null");
            return this;
        }
        
        public Criteria andCrEqualTo(Double value)
        {
            addCriterion("Cr =", value, "cr");
            return this;
        }
        
        public Criteria andCrNotEqualTo(Double value)
        {
            addCriterion("Cr <>", value, "cr");
            return this;
        }
        
        public Criteria andCrGreaterThan(Double value)
        {
            addCriterion("Cr >", value, "cr");
            return this;
        }
        
        public Criteria andCrGreaterThanOrEqualTo(Double value)
        {
            addCriterion("Cr >=", value, "cr");
            return this;
        }
        
        public Criteria andCrLessThan(Double value)
        {
            addCriterion("Cr <", value, "cr");
            return this;
        }
        
        public Criteria andCrLessThanOrEqualTo(Double value)
        {
            addCriterion("Cr <=", value, "cr");
            return this;
        }
        
        public Criteria andCrIn(List<Double> values)
        {
            addCriterion("Cr in", values, "cr");
            return this;
        }
        
        public Criteria andCrNotIn(List<Double> values)
        {
            addCriterion("Cr not in", values, "cr");
            return this;
        }
        
        public Criteria andCrBetween(Double value1, Double value2)
        {
            addCriterion("Cr between", value1, value2, "cr");
            return this;
        }
        
        public Criteria andCrNotBetween(Double value1, Double value2)
        {
            addCriterion("Cr not between", value1, value2, "cr");
            return this;
        }
        
        public Criteria andCdIsNull()
        {
            addCriterion("Cd is null");
            return this;
        }
        
        public Criteria andCdIsNotNull()
        {
            addCriterion("Cd is not null");
            return this;
        }
        
        public Criteria andCdEqualTo(Double value)
        {
            addCriterion("Cd =", value, "cd");
            return this;
        }
        
        public Criteria andCdNotEqualTo(Double value)
        {
            addCriterion("Cd <>", value, "cd");
            return this;
        }
        
        public Criteria andCdGreaterThan(Double value)
        {
            addCriterion("Cd >", value, "cd");
            return this;
        }
        
        public Criteria andCdGreaterThanOrEqualTo(Double value)
        {
            addCriterion("Cd >=", value, "cd");
            return this;
        }
        
        public Criteria andCdLessThan(Double value)
        {
            addCriterion("Cd <", value, "cd");
            return this;
        }
        
        public Criteria andCdLessThanOrEqualTo(Double value)
        {
            addCriterion("Cd <=", value, "cd");
            return this;
        }
        
        public Criteria andCdIn(List<Double> values)
        {
            addCriterion("Cd in", values, "cd");
            return this;
        }
        
        public Criteria andCdNotIn(List<Double> values)
        {
            addCriterion("Cd not in", values, "cd");
            return this;
        }
        
        public Criteria andCdBetween(Double value1, Double value2)
        {
            addCriterion("Cd between", value1, value2, "cd");
            return this;
        }
        
        public Criteria andCdNotBetween(Double value1, Double value2)
        {
            addCriterion("Cd not between", value1, value2, "cd");
            return this;
        }
        
        public Criteria andCuIsNull()
        {
            addCriterion("Cu is null");
            return this;
        }
        
        public Criteria andCuIsNotNull()
        {
            addCriterion("Cu is not null");
            return this;
        }
        
        public Criteria andCuEqualTo(Double value)
        {
            addCriterion("Cu =", value, "cu");
            return this;
        }
        
        public Criteria andCuNotEqualTo(Double value)
        {
            addCriterion("Cu <>", value, "cu");
            return this;
        }
        
        public Criteria andCuGreaterThan(Double value)
        {
            addCriterion("Cu >", value, "cu");
            return this;
        }
        
        public Criteria andCuGreaterThanOrEqualTo(Double value)
        {
            addCriterion("Cu >=", value, "cu");
            return this;
        }
        
        public Criteria andCuLessThan(Double value)
        {
            addCriterion("Cu <", value, "cu");
            return this;
        }
        
        public Criteria andCuLessThanOrEqualTo(Double value)
        {
            addCriterion("Cu <=", value, "cu");
            return this;
        }
        
        public Criteria andCuIn(List<Double> values)
        {
            addCriterion("Cu in", values, "cu");
            return this;
        }
        
        public Criteria andCuNotIn(List<Double> values)
        {
            addCriterion("Cu not in", values, "cu");
            return this;
        }
        
        public Criteria andCuBetween(Double value1, Double value2)
        {
            addCriterion("Cu between", value1, value2, "cu");
            return this;
        }
        
        public Criteria andCuNotBetween(Double value1, Double value2)
        {
            addCriterion("Cu not between", value1, value2, "cu");
            return this;
        }
        
        public Criteria andPbIsNull()
        {
            addCriterion("Pb is null");
            return this;
        }
        
        public Criteria andPbIsNotNull()
        {
            addCriterion("Pb is not null");
            return this;
        }
        
        public Criteria andPbEqualTo(Double value)
        {
            addCriterion("Pb =", value, "pb");
            return this;
        }
        
        public Criteria andPbNotEqualTo(Double value)
        {
            addCriterion("Pb <>", value, "pb");
            return this;
        }
        
        public Criteria andPbGreaterThan(Double value)
        {
            addCriterion("Pb >", value, "pb");
            return this;
        }
        
        public Criteria andPbGreaterThanOrEqualTo(Double value)
        {
            addCriterion("Pb >=", value, "pb");
            return this;
        }
        
        public Criteria andPbLessThan(Double value)
        {
            addCriterion("Pb <", value, "pb");
            return this;
        }
        
        public Criteria andPbLessThanOrEqualTo(Double value)
        {
            addCriterion("Pb <=", value, "pb");
            return this;
        }
        
        public Criteria andPbIn(List<Double> values)
        {
            addCriterion("Pb in", values, "pb");
            return this;
        }
        
        public Criteria andPbNotIn(List<Double> values)
        {
            addCriterion("Pb not in", values, "pb");
            return this;
        }
        
        public Criteria andPbBetween(Double value1, Double value2)
        {
            addCriterion("Pb between", value1, value2, "pb");
            return this;
        }
        
        public Criteria andPbNotBetween(Double value1, Double value2)
        {
            addCriterion("Pb not between", value1, value2, "pb");
            return this;
        }
        
        public Criteria andZnIsNull()
        {
            addCriterion("Zn is null");
            return this;
        }
        
        public Criteria andZnIsNotNull()
        {
            addCriterion("Zn is not null");
            return this;
        }
        
        public Criteria andZnEqualTo(Double value)
        {
            addCriterion("Zn =", value, "zn");
            return this;
        }
        
        public Criteria andZnNotEqualTo(Double value)
        {
            addCriterion("Zn <>", value, "zn");
            return this;
        }
        
        public Criteria andZnGreaterThan(Double value)
        {
            addCriterion("Zn >", value, "zn");
            return this;
        }
        
        public Criteria andZnGreaterThanOrEqualTo(Double value)
        {
            addCriterion("Zn >=", value, "zn");
            return this;
        }
        
        public Criteria andZnLessThan(Double value)
        {
            addCriterion("Zn <", value, "zn");
            return this;
        }
        
        public Criteria andZnLessThanOrEqualTo(Double value)
        {
            addCriterion("Zn <=", value, "zn");
            return this;
        }
        
        public Criteria andZnIn(List<Double> values)
        {
            addCriterion("Zn in", values, "zn");
            return this;
        }
        
        public Criteria andZnNotIn(List<Double> values)
        {
            addCriterion("Zn not in", values, "zn");
            return this;
        }
        
        public Criteria andZnBetween(Double value1, Double value2)
        {
            addCriterion("Zn between", value1, value2, "zn");
            return this;
        }
        
        public Criteria andZnNotBetween(Double value1, Double value2)
        {
            addCriterion("Zn not between", value1, value2, "zn");
            return this;
        }
        
        public Criteria andNiIsNull()
        {
            addCriterion("Ni is null");
            return this;
        }
        
        public Criteria andNiIsNotNull()
        {
            addCriterion("Ni is not null");
            return this;
        }
        
        public Criteria andNiEqualTo(Double value)
        {
            addCriterion("Ni =", value, "ni");
            return this;
        }
        
        public Criteria andNiNotEqualTo(Double value)
        {
            addCriterion("Ni <>", value, "ni");
            return this;
        }
        
        public Criteria andNiGreaterThan(Double value)
        {
            addCriterion("Ni >", value, "ni");
            return this;
        }
        
        public Criteria andNiGreaterThanOrEqualTo(Double value)
        {
            addCriterion("Ni >=", value, "ni");
            return this;
        }
        
        public Criteria andNiLessThan(Double value)
        {
            addCriterion("Ni <", value, "ni");
            return this;
        }
        
        public Criteria andNiLessThanOrEqualTo(Double value)
        {
            addCriterion("Ni <=", value, "ni");
            return this;
        }
        
        public Criteria andNiIn(List<Double> values)
        {
            addCriterion("Ni in", values, "ni");
            return this;
        }
        
        public Criteria andNiNotIn(List<Double> values)
        {
            addCriterion("Ni not in", values, "ni");
            return this;
        }
        
        public Criteria andNiBetween(Double value1, Double value2)
        {
            addCriterion("Ni between", value1, value2, "ni");
            return this;
        }
        
        public Criteria andNiNotBetween(Double value1, Double value2)
        {
            addCriterion("Ni not between", value1, value2, "ni");
            return this;
        }
        
        public Criteria andHgIsNull()
        {
            addCriterion("Hg is null");
            return this;
        }
        
        public Criteria andHgIsNotNull()
        {
            addCriterion("Hg is not null");
            return this;
        }
        
        public Criteria andHgEqualTo(Double value)
        {
            addCriterion("Hg =", value, "hg");
            return this;
        }
        
        public Criteria andHgNotEqualTo(Double value)
        {
            addCriterion("Hg <>", value, "hg");
            return this;
        }
        
        public Criteria andHgGreaterThan(Double value)
        {
            addCriterion("Hg >", value, "hg");
            return this;
        }
        
        public Criteria andHgGreaterThanOrEqualTo(Double value)
        {
            addCriterion("Hg >=", value, "hg");
            return this;
        }
        
        public Criteria andHgLessThan(Double value)
        {
            addCriterion("Hg <", value, "hg");
            return this;
        }
        
        public Criteria andHgLessThanOrEqualTo(Double value)
        {
            addCriterion("Hg <=", value, "hg");
            return this;
        }
        
        public Criteria andHgIn(List<Double> values)
        {
            addCriterion("Hg in", values, "hg");
            return this;
        }
        
        public Criteria andHgNotIn(List<Double> values)
        {
            addCriterion("Hg not in", values, "hg");
            return this;
        }
        
        public Criteria andHgBetween(Double value1, Double value2)
        {
            addCriterion("Hg between", value1, value2, "hg");
            return this;
        }
        
        public Criteria andHgNotBetween(Double value1, Double value2)
        {
            addCriterion("Hg not between", value1, value2, "hg");
            return this;
        }
        
        public Criteria andSnIsNull()
        {
            addCriterion("Sn is null");
            return this;
        }
        
        public Criteria andSnIsNotNull()
        {
            addCriterion("Sn is not null");
            return this;
        }
        
        public Criteria andSnEqualTo(Double value)
        {
            addCriterion("Sn =", value, "sn");
            return this;
        }
        
        public Criteria andSnNotEqualTo(Double value)
        {
            addCriterion("Sn <>", value, "sn");
            return this;
        }
        
        public Criteria andSnGreaterThan(Double value)
        {
            addCriterion("Sn >", value, "sn");
            return this;
        }
        
        public Criteria andSnGreaterThanOrEqualTo(Double value)
        {
            addCriterion("Sn >=", value, "sn");
            return this;
        }
        
        public Criteria andSnLessThan(Double value)
        {
            addCriterion("Sn <", value, "sn");
            return this;
        }
        
        public Criteria andSnLessThanOrEqualTo(Double value)
        {
            addCriterion("Sn <=", value, "sn");
            return this;
        }
        
        public Criteria andSnIn(List<Double> values)
        {
            addCriterion("Sn in", values, "sn");
            return this;
        }
        
        public Criteria andSnNotIn(List<Double> values)
        {
            addCriterion("Sn not in", values, "sn");
            return this;
        }
        
        public Criteria andSnBetween(Double value1, Double value2)
        {
            addCriterion("Sn between", value1, value2, "sn");
            return this;
        }
        
        public Criteria andSnNotBetween(Double value1, Double value2)
        {
            addCriterion("Sn not between", value1, value2, "sn");
            return this;
        }
        
        public Criteria andCoIsNull()
        {
            addCriterion("Co is null");
            return this;
        }
        
        public Criteria andCoIsNotNull()
        {
            addCriterion("Co is not null");
            return this;
        }
        
        public Criteria andCoEqualTo(Double value)
        {
            addCriterion("Co =", value, "co");
            return this;
        }
        
        public Criteria andCoNotEqualTo(Double value)
        {
            addCriterion("Co <>", value, "co");
            return this;
        }
        
        public Criteria andCoGreaterThan(Double value)
        {
            addCriterion("Co >", value, "co");
            return this;
        }
        
        public Criteria andCoGreaterThanOrEqualTo(Double value)
        {
            addCriterion("Co >=", value, "co");
            return this;
        }
        
        public Criteria andCoLessThan(Double value)
        {
            addCriterion("Co <", value, "co");
            return this;
        }
        
        public Criteria andCoLessThanOrEqualTo(Double value)
        {
            addCriterion("Co <=", value, "co");
            return this;
        }
        
        public Criteria andCoIn(List<Double> values)
        {
            addCriterion("Co in", values, "co");
            return this;
        }
        
        public Criteria andCoNotIn(List<Double> values)
        {
            addCriterion("Co not in", values, "co");
            return this;
        }
        
        public Criteria andCoBetween(Double value1, Double value2)
        {
            addCriterion("Co between", value1, value2, "co");
            return this;
        }
        
        public Criteria andCoNotBetween(Double value1, Double value2)
        {
            addCriterion("Co not between", value1, value2, "co");
            return this;
        }
        
        public Criteria andAgIsNull()
        {
            addCriterion("Ag is null");
            return this;
        }
        
        public Criteria andAgIsNotNull()
        {
            addCriterion("Ag is not null");
            return this;
        }
        
        public Criteria andAgEqualTo(Double value)
        {
            addCriterion("Ag =", value, "ag");
            return this;
        }
        
        public Criteria andAgNotEqualTo(Double value)
        {
            addCriterion("Ag <>", value, "ag");
            return this;
        }
        
        public Criteria andAgGreaterThan(Double value)
        {
            addCriterion("Ag >", value, "ag");
            return this;
        }
        
        public Criteria andAgGreaterThanOrEqualTo(Double value)
        {
            addCriterion("Ag >=", value, "ag");
            return this;
        }
        
        public Criteria andAgLessThan(Double value)
        {
            addCriterion("Ag <", value, "ag");
            return this;
        }
        
        public Criteria andAgLessThanOrEqualTo(Double value)
        {
            addCriterion("Ag <=", value, "ag");
            return this;
        }
        
        public Criteria andAgIn(List<Double> values)
        {
            addCriterion("Ag in", values, "ag");
            return this;
        }
        
        public Criteria andAgNotIn(List<Double> values)
        {
            addCriterion("Ag not in", values, "ag");
            return this;
        }
        
        public Criteria andAgBetween(Double value1, Double value2)
        {
            addCriterion("Ag between", value1, value2, "ag");
            return this;
        }
        
        public Criteria andAgNotBetween(Double value1, Double value2)
        {
            addCriterion("Ag not between", value1, value2, "ag");
            return this;
        }
        
        public Criteria andSbIsNull()
        {
            addCriterion("Sb is null");
            return this;
        }
        
        public Criteria andSbIsNotNull()
        {
            addCriterion("Sb is not null");
            return this;
        }
        
        public Criteria andSbEqualTo(Double value)
        {
            addCriterion("Sb =", value, "sb");
            return this;
        }
        
        public Criteria andSbNotEqualTo(Double value)
        {
            addCriterion("Sb <>", value, "sb");
            return this;
        }
        
        public Criteria andSbGreaterThan(Double value)
        {
            addCriterion("Sb >", value, "sb");
            return this;
        }
        
        public Criteria andSbGreaterThanOrEqualTo(Double value)
        {
            addCriterion("Sb >=", value, "sb");
            return this;
        }
        
        public Criteria andSbLessThan(Double value)
        {
            addCriterion("Sb <", value, "sb");
            return this;
        }
        
        public Criteria andSbLessThanOrEqualTo(Double value)
        {
            addCriterion("Sb <=", value, "sb");
            return this;
        }
        
        public Criteria andSbIn(List<Double> values)
        {
            addCriterion("Sb in", values, "sb");
            return this;
        }
        
        public Criteria andSbNotIn(List<Double> values)
        {
            addCriterion("Sb not in", values, "sb");
            return this;
        }
        
        public Criteria andSbBetween(Double value1, Double value2)
        {
            addCriterion("Sb between", value1, value2, "sb");
            return this;
        }
        
        public Criteria andSbNotBetween(Double value1, Double value2)
        {
            addCriterion("Sb not between", value1, value2, "sb");
            return this;
        }
        
        public Criteria andBaIsNull()
        {
            addCriterion("Ba is null");
            return this;
        }
        
        public Criteria andBaIsNotNull()
        {
            addCriterion("Ba is not null");
            return this;
        }
        
        public Criteria andBaEqualTo(Double value)
        {
            addCriterion("Ba =", value, "ba");
            return this;
        }
        
        public Criteria andBaNotEqualTo(Double value)
        {
            addCriterion("Ba <>", value, "ba");
            return this;
        }
        
        public Criteria andBaGreaterThan(Double value)
        {
            addCriterion("Ba >", value, "ba");
            return this;
        }
        
        public Criteria andBaGreaterThanOrEqualTo(Double value)
        {
            addCriterion("Ba >=", value, "ba");
            return this;
        }
        
        public Criteria andBaLessThan(Double value)
        {
            addCriterion("Ba <", value, "ba");
            return this;
        }
        
        public Criteria andBaLessThanOrEqualTo(Double value)
        {
            addCriterion("Ba <=", value, "ba");
            return this;
        }
        
        public Criteria andBaIn(List<Double> values)
        {
            addCriterion("Ba in", values, "ba");
            return this;
        }
        
        public Criteria andBaNotIn(List<Double> values)
        {
            addCriterion("Ba not in", values, "ba");
            return this;
        }
        
        public Criteria andBaBetween(Double value1, Double value2)
        {
            addCriterion("Ba between", value1, value2, "ba");
            return this;
        }
        
        public Criteria andBaNotBetween(Double value1, Double value2)
        {
            addCriterion("Ba not between", value1, value2, "ba");
            return this;
        }
        
        public Criteria andMgIsNull()
        {
            addCriterion("Mg is null");
            return this;
        }
        
        public Criteria andMgIsNotNull()
        {
            addCriterion("Mg is not null");
            return this;
        }
        
        public Criteria andMgEqualTo(Double value)
        {
            addCriterion("Mg =", value, "mg");
            return this;
        }
        
        public Criteria andMgNotEqualTo(Double value)
        {
            addCriterion("Mg <>", value, "mg");
            return this;
        }
        
        public Criteria andMgGreaterThan(Double value)
        {
            addCriterion("Mg >", value, "mg");
            return this;
        }
        
        public Criteria andMgGreaterThanOrEqualTo(Double value)
        {
            addCriterion("Mg >=", value, "mg");
            return this;
        }
        
        public Criteria andMgLessThan(Double value)
        {
            addCriterion("Mg <", value, "mg");
            return this;
        }
        
        public Criteria andMgLessThanOrEqualTo(Double value)
        {
            addCriterion("Mg <=", value, "mg");
            return this;
        }
        
        public Criteria andMgIn(List<Double> values)
        {
            addCriterion("Mg in", values, "mg");
            return this;
        }
        
        public Criteria andMgNotIn(List<Double> values)
        {
            addCriterion("Mg not in", values, "mg");
            return this;
        }
        
        public Criteria andMgBetween(Double value1, Double value2)
        {
            addCriterion("Mg between", value1, value2, "mg");
            return this;
        }
        
        public Criteria andMgNotBetween(Double value1, Double value2)
        {
            addCriterion("Mg not between", value1, value2, "mg");
            return this;
        }
        
        public Criteria andTiIsNull()
        {
            addCriterion("Ti is null");
            return this;
        }
        
        public Criteria andTiIsNotNull()
        {
            addCriterion("Ti is not null");
            return this;
        }
        
        public Criteria andTiEqualTo(Double value)
        {
            addCriterion("Ti =", value, "ti");
            return this;
        }
        
        public Criteria andTiNotEqualTo(Double value)
        {
            addCriterion("Ti <>", value, "ti");
            return this;
        }
        
        public Criteria andTiGreaterThan(Double value)
        {
            addCriterion("Ti >", value, "ti");
            return this;
        }
        
        public Criteria andTiGreaterThanOrEqualTo(Double value)
        {
            addCriterion("Ti >=", value, "ti");
            return this;
        }
        
        public Criteria andTiLessThan(Double value)
        {
            addCriterion("Ti <", value, "ti");
            return this;
        }
        
        public Criteria andTiLessThanOrEqualTo(Double value)
        {
            addCriterion("Ti <=", value, "ti");
            return this;
        }
        
        public Criteria andTiIn(List<Double> values)
        {
            addCriterion("Ti in", values, "ti");
            return this;
        }
        
        public Criteria andTiNotIn(List<Double> values)
        {
            addCriterion("Ti not in", values, "ti");
            return this;
        }
        
        public Criteria andTiBetween(Double value1, Double value2)
        {
            addCriterion("Ti between", value1, value2, "ti");
            return this;
        }
        
        public Criteria andTiNotBetween(Double value1, Double value2)
        {
            addCriterion("Ti not between", value1, value2, "ti");
            return this;
        }
        
        public Criteria andWIsNull()
        {
            addCriterion("W is null");
            return this;
        }
        
        public Criteria andWIsNotNull()
        {
            addCriterion("W is not null");
            return this;
        }
        
        public Criteria andWEqualTo(Double value)
        {
            addCriterion("W =", value, "w");
            return this;
        }
        
        public Criteria andWNotEqualTo(Double value)
        {
            addCriterion("W <>", value, "w");
            return this;
        }
        
        public Criteria andWGreaterThan(Double value)
        {
            addCriterion("W >", value, "w");
            return this;
        }
        
        public Criteria andWGreaterThanOrEqualTo(Double value)
        {
            addCriterion("W >=", value, "w");
            return this;
        }
        
        public Criteria andWLessThan(Double value)
        {
            addCriterion("W <", value, "w");
            return this;
        }
        
        public Criteria andWLessThanOrEqualTo(Double value)
        {
            addCriterion("W <=", value, "w");
            return this;
        }
        
        public Criteria andWIn(List<Double> values)
        {
            addCriterion("W in", values, "w");
            return this;
        }
        
        public Criteria andWNotIn(List<Double> values)
        {
            addCriterion("W not in", values, "w");
            return this;
        }
        
        public Criteria andWBetween(Double value1, Double value2)
        {
            addCriterion("W between", value1, value2, "w");
            return this;
        }
        
        public Criteria andWNotBetween(Double value1, Double value2)
        {
            addCriterion("W not between", value1, value2, "w");
            return this;
        }
        
        public Criteria andAlIsNull()
        {
            addCriterion("Al is null");
            return this;
        }
        
        public Criteria andAlIsNotNull()
        {
            addCriterion("Al is not null");
            return this;
        }
        
        public Criteria andAlEqualTo(Double value)
        {
            addCriterion("Al =", value, "al");
            return this;
        }
        
        public Criteria andAlNotEqualTo(Double value)
        {
            addCriterion("Al <>", value, "al");
            return this;
        }
        
        public Criteria andAlGreaterThan(Double value)
        {
            addCriterion("Al >", value, "al");
            return this;
        }
        
        public Criteria andAlGreaterThanOrEqualTo(Double value)
        {
            addCriterion("Al >=", value, "al");
            return this;
        }
        
        public Criteria andAlLessThan(Double value)
        {
            addCriterion("Al <", value, "al");
            return this;
        }
        
        public Criteria andAlLessThanOrEqualTo(Double value)
        {
            addCriterion("Al <=", value, "al");
            return this;
        }
        
        public Criteria andAlIn(List<Double> values)
        {
            addCriterion("Al in", values, "al");
            return this;
        }
        
        public Criteria andAlNotIn(List<Double> values)
        {
            addCriterion("Al not in", values, "al");
            return this;
        }
        
        public Criteria andAlBetween(Double value1, Double value2)
        {
            addCriterion("Al between", value1, value2, "al");
            return this;
        }
        
        public Criteria andAlNotBetween(Double value1, Double value2)
        {
            addCriterion("Al not between", value1, value2, "al");
            return this;
        }
        
        public Criteria andThIsNull()
        {
            addCriterion("Th is null");
            return this;
        }
        
        public Criteria andThIsNotNull()
        {
            addCriterion("Th is not null");
            return this;
        }
        
        public Criteria andThEqualTo(Double value)
        {
            addCriterion("Th =", value, "th");
            return this;
        }
        
        public Criteria andThNotEqualTo(Double value)
        {
            addCriterion("Th <>", value, "th");
            return this;
        }
        
        public Criteria andThGreaterThan(Double value)
        {
            addCriterion("Th >", value, "th");
            return this;
        }
        
        public Criteria andThGreaterThanOrEqualTo(Double value)
        {
            addCriterion("Th >=", value, "th");
            return this;
        }
        
        public Criteria andThLessThan(Double value)
        {
            addCriterion("Th <", value, "th");
            return this;
        }
        
        public Criteria andThLessThanOrEqualTo(Double value)
        {
            addCriterion("Th <=", value, "th");
            return this;
        }
        
        public Criteria andThIn(List<Double> values)
        {
            addCriterion("Th in", values, "th");
            return this;
        }
        
        public Criteria andThNotIn(List<Double> values)
        {
            addCriterion("Th not in", values, "th");
            return this;
        }
        
        public Criteria andThBetween(Double value1, Double value2)
        {
            addCriterion("Th between", value1, value2, "th");
            return this;
        }
        
        public Criteria andThNotBetween(Double value1, Double value2)
        {
            addCriterion("Th not between", value1, value2, "th");
            return this;
        }
        
        public Criteria andSrIsNull()
        {
            addCriterion("Sr is null");
            return this;
        }
        
        public Criteria andSrIsNotNull()
        {
            addCriterion("Sr is not null");
            return this;
        }
        
        public Criteria andSrEqualTo(Double value)
        {
            addCriterion("Sr =", value, "sr");
            return this;
        }
        
        public Criteria andSrNotEqualTo(Double value)
        {
            addCriterion("Sr <>", value, "sr");
            return this;
        }
        
        public Criteria andSrGreaterThan(Double value)
        {
            addCriterion("Sr >", value, "sr");
            return this;
        }
        
        public Criteria andSrGreaterThanOrEqualTo(Double value)
        {
            addCriterion("Sr >=", value, "sr");
            return this;
        }
        
        public Criteria andSrLessThan(Double value)
        {
            addCriterion("Sr <", value, "sr");
            return this;
        }
        
        public Criteria andSrLessThanOrEqualTo(Double value)
        {
            addCriterion("Sr <=", value, "sr");
            return this;
        }
        
        public Criteria andSrIn(List<Double> values)
        {
            addCriterion("Sr in", values, "sr");
            return this;
        }
        
        public Criteria andSrNotIn(List<Double> values)
        {
            addCriterion("Sr not in", values, "sr");
            return this;
        }
        
        public Criteria andSrBetween(Double value1, Double value2)
        {
            addCriterion("Sr between", value1, value2, "sr");
            return this;
        }
        
        public Criteria andSrNotBetween(Double value1, Double value2)
        {
            addCriterion("Sr not between", value1, value2, "sr");
            return this;
        }
        
        public Criteria andCsIsNull()
        {
            addCriterion("Cs is null");
            return this;
        }
        
        public Criteria andCsIsNotNull()
        {
            addCriterion("Cs is not null");
            return this;
        }
        
        public Criteria andCsEqualTo(Double value)
        {
            addCriterion("Cs =", value, "cs");
            return this;
        }
        
        public Criteria andCsNotEqualTo(Double value)
        {
            addCriterion("Cs <>", value, "cs");
            return this;
        }
        
        public Criteria andCsGreaterThan(Double value)
        {
            addCriterion("Cs >", value, "cs");
            return this;
        }
        
        public Criteria andCsGreaterThanOrEqualTo(Double value)
        {
            addCriterion("Cs >=", value, "cs");
            return this;
        }
        
        public Criteria andCsLessThan(Double value)
        {
            addCriterion("Cs <", value, "cs");
            return this;
        }
        
        public Criteria andCsLessThanOrEqualTo(Double value)
        {
            addCriterion("Cs <=", value, "cs");
            return this;
        }
        
        public Criteria andCsIn(List<Double> values)
        {
            addCriterion("Cs in", values, "cs");
            return this;
        }
        
        public Criteria andCsNotIn(List<Double> values)
        {
            addCriterion("Cs not in", values, "cs");
            return this;
        }
        
        public Criteria andCsBetween(Double value1, Double value2)
        {
            addCriterion("Cs between", value1, value2, "cs");
            return this;
        }
        
        public Criteria andCsNotBetween(Double value1, Double value2)
        {
            addCriterion("Cs not between", value1, value2, "cs");
            return this;
        }
    }
}